home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / interp / perl5.005.tar.gz / perl5.005.tar / perl5.005 / config_h.SH < prev    next >
Text File  |  1998-07-15  |  67KB  |  2,119 lines
  1. case $CONFIG in
  2. '')
  3.     if test -f config.sh; then TOP=.;
  4.     elif test -f ../config.sh; then TOP=..;
  5.     elif test -f ../../config.sh; then TOP=../..;
  6.     elif test -f ../../../config.sh; then TOP=../../..;
  7.     elif test -f ../../../../config.sh; then TOP=../../../..;
  8.     else
  9.         echo "Can't find config.sh."; exit 1
  10.     fi
  11.     . $TOP/config.sh
  12.     ;;
  13. esac
  14. case "$0" in
  15. */*) cd `expr X$0 : 'X\(.*\)/'` ;;
  16. esac
  17. echo "Extracting config.h (with variable substitutions)"
  18. sed <<!GROK!THIS! >config.h -e 's!^#undef\(.*/\)\*!/\*#define\1 \*!' -e 's!^#un-def!#undef!'
  19. /*
  20.  * This file was produced by running the config_h.SH script, which
  21.  * gets its values from config.sh, which is generally produced by
  22.  * running Configure.
  23.  *
  24.  * Feel free to modify any of this as the need arises.  Note, however,
  25.  * that running config_h.SH again will wipe out any changes you've made.
  26.  * For a more permanent change edit config.sh and rerun config_h.SH.
  27.  *
  28.  * \$Id: Config_h.U,v 3.0.1.5 1997/02/28 14:57:43 ram Exp $
  29.  */
  30.  
  31. /*
  32.  * Package name      : $package
  33.  * Source directory  : $src
  34.  * Configuration time: $cf_time
  35.  * Configured by     : $cf_by
  36.  * Target system     : $myuname
  37.  */
  38.  
  39. #ifndef _config_h_
  40. #define _config_h_
  41.  
  42. /* LOC_SED:
  43.  *    This symbol holds the complete pathname to the sed program.
  44.  */
  45. #define LOC_SED     "$full_sed"    /**/
  46.  
  47. /* BIN:
  48.  *    This symbol holds the path of the bin directory where the package will
  49.  *    be installed. Program must be prepared to deal with ~name substitution.
  50.  */
  51. /* BIN_EXP:
  52.  *    This symbol is the filename expanded version of the BIN symbol, for
  53.  *    programs that do not want to deal with that at run-time.
  54.  */
  55. #define BIN "$bin"    /**/
  56. #define BIN_EXP "$binexp"    /**/
  57.  
  58. /* CPPSTDIN:
  59.  *    This symbol contains the first part of the string which will invoke
  60.  *    the C preprocessor on the standard input and produce to standard
  61.  *    output.     Typical value of "cc -E" or "/lib/cpp", but it can also
  62.  *    call a wrapper. See CPPRUN.
  63.  */
  64. /* CPPMINUS:
  65.  *    This symbol contains the second part of the string which will invoke
  66.  *    the C preprocessor on the standard input and produce to standard
  67.  *    output.  This symbol will have the value "-" if CPPSTDIN needs a minus
  68.  *    to specify standard input, otherwise the value is "".
  69.  */
  70. #define CPPSTDIN "$cppstdin"
  71. #define CPPMINUS "$cppminus"
  72.  
  73. /* HAS_ALARM:
  74.  *    This symbol, if defined, indicates that the alarm routine is
  75.  *    available.
  76.  */
  77. #$d_alarm HAS_ALARM        /**/
  78.  
  79. /* HASATTRIBUTE:
  80.  *    This symbol indicates the C compiler can check for function attributes,
  81.  *    such as printf formats. This is normally only supported by GNU cc.
  82.  */
  83. #$d_attribut HASATTRIBUTE     /**/
  84. #ifndef HASATTRIBUTE
  85. #define __attribute__(_arg_)
  86. #endif
  87.  
  88. /* HAS_BCMP:
  89.  *    This symbol is defined if the bcmp() routine is available to
  90.  *    compare blocks of memory.
  91.  */
  92. #$d_bcmp HAS_BCMP    /**/
  93.  
  94. /* HAS_BCOPY:
  95.  *    This symbol is defined if the bcopy() routine is available to
  96.  *    copy blocks of memory.
  97.  */
  98. #$d_bcopy HAS_BCOPY    /**/
  99.  
  100. /* HAS_BZERO:
  101.  *    This symbol is defined if the bzero() routine is available to
  102.  *    set a memory block to 0.
  103.  */
  104. #$d_bzero HAS_BZERO    /**/
  105.  
  106. /* HAS_CHOWN:
  107.  *    This symbol, if defined, indicates that the chown routine is
  108.  *    available.
  109.  */
  110. #$d_chown HAS_CHOWN        /**/
  111.  
  112. /* HAS_CHROOT:
  113.  *    This symbol, if defined, indicates that the chroot routine is
  114.  *    available.
  115.  */
  116. #$d_chroot HAS_CHROOT        /**/
  117.  
  118. /* HAS_CHSIZE:
  119.  *    This symbol, if defined, indicates that the chsize routine is available
  120.  *    to truncate files.  You might need a -lx to get this routine.
  121.  */
  122. #$d_chsize    HAS_CHSIZE        /**/
  123.  
  124. /* HASCONST:
  125.  *    This symbol, if defined, indicates that this C compiler knows about
  126.  *    the const type. There is no need to actually test for that symbol
  127.  *    within your programs. The mere use of the "const" keyword will
  128.  *    trigger the necessary tests.
  129.  */
  130. #$d_const HASCONST    /**/
  131. #ifndef HASCONST
  132. #define const
  133. #endif
  134.  
  135. /* HAS_CRYPT:
  136.  *    This symbol, if defined, indicates that the crypt routine is available
  137.  *    to encrypt passwords and the like.
  138.  */
  139. #$d_crypt HAS_CRYPT        /**/
  140.  
  141. /* HAS_CUSERID:
  142.  *    This symbol, if defined, indicates that the cuserid routine is
  143.  *    available to get character login names.
  144.  */
  145. #$d_cuserid HAS_CUSERID        /**/
  146.  
  147. /* HAS_DBL_DIG:
  148.  *    This symbol, if defined, indicates that this system's <float.h>
  149.  *    or <limits.h> defines the symbol DBL_DIG, which is the number
  150.  *    of significant digits in a double precision number.  If this
  151.  *    symbol is not defined, a guess of 15 is usually pretty good.
  152.  */
  153. #$d_dbl_dig HAS_DBL_DIG     /* */
  154.  
  155. /* HAS_DIFFTIME:
  156.  *    This symbol, if defined, indicates that the difftime routine is
  157.  *    available.
  158.  */
  159. #$d_difftime HAS_DIFFTIME        /**/
  160.  
  161. /* HAS_DLERROR:
  162.  *    This symbol, if defined, indicates that the dlerror routine is
  163.  *    available to return a string describing the last error that
  164.  *    occurred from a call to dlopen(), dlclose() or dlsym().
  165.  */
  166. #$d_dlerror HAS_DLERROR    /**/
  167.  
  168. /* SETUID_SCRIPTS_ARE_SECURE_NOW:
  169.  *    This symbol, if defined, indicates that the bug that prevents
  170.  *    setuid scripts from being secure is not present in this kernel.
  171.  */
  172. /* DOSUID:
  173.  *    This symbol, if defined, indicates that the C program should
  174.  *    check the script that it is executing for setuid/setgid bits, and
  175.  *    attempt to emulate setuid/setgid on systems that have disabled
  176.  *    setuid #! scripts because the kernel can't do it securely.
  177.  *    It is up to the package designer to make sure that this emulation
  178.  *    is done securely.  Among other things, it should do an fstat on
  179.  *    the script it just opened to make sure it really is a setuid/setgid
  180.  *    script, it should make sure the arguments passed correspond exactly
  181.  *    to the argument on the #! line, and it should not trust any
  182.  *    subprocesses to which it must pass the filename rather than the
  183.  *    file descriptor of the script to be executed.
  184.  */
  185. #$d_suidsafe SETUID_SCRIPTS_ARE_SECURE_NOW    /**/
  186. #$d_dosuid DOSUID        /**/
  187.  
  188. /* HAS_DUP2:
  189.  *    This symbol, if defined, indicates that the dup2 routine is
  190.  *    available to duplicate file descriptors.
  191.  */
  192. #$d_dup2 HAS_DUP2    /**/
  193.  
  194. /* HAS_FCHMOD:
  195.  *    This symbol, if defined, indicates that the fchmod routine is available
  196.  *    to change mode of opened files.  If unavailable, use chmod().
  197.  */
  198. #$d_fchmod HAS_FCHMOD        /**/
  199.  
  200. /* HAS_FCHOWN:
  201.  *    This symbol, if defined, indicates that the fchown routine is available
  202.  *    to change ownership of opened files.  If unavailable, use chown().
  203.  */
  204. #$d_fchown HAS_FCHOWN        /**/
  205.  
  206. /* HAS_FCNTL:
  207.  *    This symbol, if defined, indicates to the C program that
  208.  *    the fcntl() function exists.
  209.  */
  210. #$d_fcntl HAS_FCNTL        /**/
  211.  
  212. /* HAS_FGETPOS:
  213.  *    This symbol, if defined, indicates that the fgetpos routine is
  214.  *    available to get the file position indicator, similar to ftell().
  215.  */
  216. #$d_fgetpos HAS_FGETPOS    /**/
  217.  
  218. /* FLEXFILENAMES:
  219.  *    This symbol, if defined, indicates that the system supports filenames
  220.  *    longer than 14 characters.
  221.  */
  222. #$d_flexfnam    FLEXFILENAMES        /**/
  223.  
  224. /* HAS_FLOCK:
  225.  *    This symbol, if defined, indicates that the flock routine is
  226.  *    available to do file locking.
  227.  */
  228. #$d_flock HAS_FLOCK        /**/
  229.  
  230. /* HAS_FORK:
  231.  *    This symbol, if defined, indicates that the fork routine is
  232.  *    available.
  233.  */
  234. #$d_fork HAS_FORK        /**/
  235.  
  236. /* HAS_FSETPOS:
  237.  *    This symbol, if defined, indicates that the fsetpos routine is
  238.  *    available to set the file position indicator, similar to fseek().
  239.  */
  240. #$d_fsetpos HAS_FSETPOS    /**/
  241.  
  242. /* HAS_GETTIMEOFDAY:
  243.  *    This symbol, if defined, indicates that the gettimeofday() system
  244.  *    call is available for a sub-second accuracy clock. Usually, the file
  245.  *    <sys/resource.h> needs to be included (see I_SYS_RESOURCE).
  246.  *    The type "Timeval" should be used to refer to "struct timeval".
  247.  */
  248. #$d_gettimeod HAS_GETTIMEOFDAY    /**/
  249. #ifdef HAS_GETTIMEOFDAY
  250. #define Timeval struct timeval    /* Structure used by gettimeofday() */
  251. #endif
  252.  
  253. /* HAS_GETGROUPS:
  254.  *    This symbol, if defined, indicates that the getgroups() routine is
  255.  *    available to get the list of process groups.  If unavailable, multiple
  256.  *    groups are probably not supported.
  257.  */
  258. #$d_getgrps HAS_GETGROUPS        /**/
  259.  
  260. /* HAS_UNAME:
  261.  *    This symbol, if defined, indicates that the C program may use the
  262.  *    uname() routine to derive the host name.  See also HAS_GETHOSTNAME
  263.  *    and PHOSTNAME.
  264.  */
  265. #$d_uname HAS_UNAME        /**/
  266.  
  267. /* HAS_GETLOGIN:
  268.  *    This symbol, if defined, indicates that the getlogin routine is
  269.  *    available to get the login name.
  270.  */
  271. #$d_getlogin HAS_GETLOGIN        /**/
  272.  
  273. /* HAS_GETPGID:
  274.  *    This symbol, if defined, indicates to the C program that 
  275.  *    the getpgid(pid) function is available to get the
  276.  *    process group id.
  277.  */
  278. #$d_getpgid HAS_GETPGID        /**/
  279.  
  280. /* HAS_GETPGRP:
  281.  *    This symbol, if defined, indicates that the getpgrp routine is
  282.  *    available to get the current process group.
  283.  */
  284. /* USE_BSD_GETPGRP:
  285.  *    This symbol, if defined, indicates that getpgrp needs one
  286.  *    arguments whereas USG one needs none.
  287.  */
  288. #$d_getpgrp HAS_GETPGRP        /**/
  289. #$d_bsdgetpgrp USE_BSD_GETPGRP    /**/
  290.  
  291. /* HAS_GETPGRP2:
  292.  *    This symbol, if defined, indicates that the getpgrp2() (as in DG/UX)
  293.  *    routine is available to get the current process group.
  294.  */
  295. #$d_getpgrp2 HAS_GETPGRP2        /**/
  296.  
  297. /* HAS_GETPPID:
  298.  *    This symbol, if defined, indicates that the getppid routine is
  299.  *    available to get the parent process ID.
  300.  */
  301. #$d_getppid HAS_GETPPID        /**/
  302.  
  303. /* HAS_GETPRIORITY:
  304.  *    This symbol, if defined, indicates that the getpriority routine is
  305.  *    available to get a process's priority.
  306.  */
  307. #$d_getprior HAS_GETPRIORITY        /**/
  308.  
  309. /* HAS_HTONL:
  310.  *    This symbol, if defined, indicates that the htonl() routine (and
  311.  *    friends htons() ntohl() ntohs()) are available to do network
  312.  *    order byte swapping.
  313.  */
  314. /* HAS_HTONS:
  315.  *    This symbol, if defined, indicates that the htons() routine (and
  316.  *    friends htonl() ntohl() ntohs()) are available to do network
  317.  *    order byte swapping.
  318.  */
  319. /* HAS_NTOHL:
  320.  *    This symbol, if defined, indicates that the ntohl() routine (and
  321.  *    friends htonl() htons() ntohs()) are available to do network
  322.  *    order byte swapping.
  323.  */
  324. /* HAS_NTOHS:
  325.  *    This symbol, if defined, indicates that the ntohs() routine (and
  326.  *    friends htonl() htons() ntohl()) are available to do network
  327.  *    order byte swapping.
  328.  */
  329. #$d_htonl HAS_HTONL        /**/
  330. #$d_htonl HAS_HTONS        /**/
  331. #$d_htonl HAS_NTOHL        /**/
  332. #$d_htonl HAS_NTOHS        /**/
  333.  
  334. /* HAS_INET_ATON:
  335.  *    This symbol, if defined, indicates to the C program that the
  336.  *    inet_aton() function is available to parse IP address "dotted-quad"
  337.  *    strings.
  338.  */
  339. #$d_inetaton HAS_INET_ATON        /**/
  340.  
  341. /* HAS_KILLPG:
  342.  *    This symbol, if defined, indicates that the killpg routine is available
  343.  *    to kill process groups.  If unavailable, you probably should use kill
  344.  *    with a negative process number.
  345.  */
  346. #$d_killpg HAS_KILLPG    /**/
  347.  
  348. /* HAS_LINK:
  349.  *    This symbol, if defined, indicates that the link routine is
  350.  *    available to create hard links.
  351.  */
  352. #$d_link HAS_LINK    /**/
  353.  
  354. /* HAS_LOCALECONV:
  355.  *    This symbol, if defined, indicates that the localeconv routine is
  356.  *    available for numeric and monetary formatting conventions.
  357.  */
  358. #$d_locconv HAS_LOCALECONV    /**/
  359.  
  360. /* HAS_LOCKF:
  361.  *    This symbol, if defined, indicates that the lockf routine is
  362.  *    available to do file locking.
  363.  */
  364. #$d_lockf HAS_LOCKF        /**/
  365.  
  366. /* HAS_LSTAT:
  367.  *    This symbol, if defined, indicates that the lstat routine is
  368.  *    available to do file stats on symbolic links.
  369.  */
  370. #$d_lstat HAS_LSTAT        /**/
  371.  
  372. /* HAS_MBLEN:
  373.  *    This symbol, if defined, indicates that the mblen routine is available
  374.  *    to find the number of bytes in a multibye character.
  375.  */
  376. #$d_mblen HAS_MBLEN        /**/
  377.  
  378. /* HAS_MBSTOWCS:
  379.  *    This symbol, if defined, indicates that the mbstowcs routine is
  380.  *    available to covert a multibyte string into a wide character string.
  381.  */
  382. #$d_mbstowcs    HAS_MBSTOWCS        /**/
  383.  
  384. /* HAS_MBTOWC:
  385.  *    This symbol, if defined, indicates that the mbtowc routine is available
  386.  *    to covert a multibyte to a wide character.
  387.  */
  388. #$d_mbtowc HAS_MBTOWC        /**/
  389.  
  390. /* HAS_MEMCMP:
  391.  *    This symbol, if defined, indicates that the memcmp routine is available
  392.  *    to compare blocks of memory.
  393.  */
  394. #$d_memcmp HAS_MEMCMP    /**/
  395.  
  396. /* HAS_MEMCPY:
  397.  *    This symbol, if defined, indicates that the memcpy routine is available
  398.  *    to copy blocks of memory.
  399.  */
  400. #$d_memcpy HAS_MEMCPY    /**/
  401.  
  402. /* HAS_MEMMOVE:
  403.  *    This symbol, if defined, indicates that the memmove routine is available
  404.  *    to copy potentially overlapping blocks of memory. This should be used
  405.  *    only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
  406.  *    own version.
  407.  */
  408. #$d_memmove HAS_MEMMOVE    /**/
  409.  
  410. /* HAS_MEMSET:
  411.  *    This symbol, if defined, indicates that the memset routine is available
  412.  *    to set blocks of memory.
  413.  */
  414. #$d_memset HAS_MEMSET    /**/
  415.  
  416. /* HAS_MKDIR:
  417.  *    This symbol, if defined, indicates that the mkdir routine is available
  418.  *    to create directories.  Otherwise you should fork off a new process to
  419.  *    exec /bin/mkdir.
  420.  */
  421. #$d_mkdir HAS_MKDIR        /**/
  422.  
  423. /* HAS_MKFIFO:
  424.  *    This symbol, if defined, indicates that the mkfifo routine is
  425.  *    available to create FIFOs. Otherwise, mknod should be able to
  426.  *    do it for you. However, if mkfifo is there, mknod might require
  427.  *    super-user privileges which mkfifo will not.
  428.  */
  429. #$d_mkfifo HAS_MKFIFO        /**/
  430.  
  431. /* HAS_MKTIME:
  432.  *    This symbol, if defined, indicates that the mktime routine is
  433.  *    available.
  434.  */
  435. #$d_mktime HAS_MKTIME        /**/
  436.  
  437. /* HAS_MSG:
  438.  *    This symbol, if defined, indicates that the entire msg*(2) library is
  439.  *    supported (IPC mechanism based on message queues).
  440.  */
  441. #$d_msg HAS_MSG        /**/
  442.  
  443. /* HAS_NICE:
  444.  *    This symbol, if defined, indicates that the nice routine is
  445.  *    available.
  446.  */
  447. #$d_nice HAS_NICE        /**/
  448.  
  449. /* HAS_PATHCONF:
  450.  *    This symbol, if defined, indicates that pathconf() is available
  451.  *    to determine file-system related limits and options associated
  452.  *    with a given filename.
  453.  */
  454. /* HAS_FPATHCONF:
  455.  *    This symbol, if defined, indicates that pathconf() is available
  456.  *    to determine file-system related limits and options associated
  457.  *    with a given open file descriptor.
  458.  */
  459. #$d_pathconf HAS_PATHCONF        /**/
  460. #$d_fpathconf HAS_FPATHCONF        /**/
  461.  
  462. /* HAS_PAUSE:
  463.  *    This symbol, if defined, indicates that the pause routine is
  464.  *    available to suspend a process until a signal is received.
  465.  */
  466. #$d_pause HAS_PAUSE        /**/
  467.  
  468. /* HAS_PIPE:
  469.  *    This symbol, if defined, indicates that the pipe routine is
  470.  *    available to create an inter-process channel.
  471.  */
  472. #$d_pipe HAS_PIPE        /**/
  473.  
  474. /* HAS_POLL:
  475.  *    This symbol, if defined, indicates that the poll routine is
  476.  *    available to poll active file descriptors. You may safely
  477.  *    include <poll.h> when this symbol is defined.
  478.  */
  479. #$d_poll HAS_POLL        /**/
  480.  
  481. /* HAS_READDIR:
  482.  *    This symbol, if defined, indicates that the readdir routine is
  483.  *    available to read directory entries. You may have to include
  484.  *    <dirent.h>. See I_DIRENT.
  485.  */
  486. #$d_readdir HAS_READDIR        /**/
  487.  
  488. /* HAS_SEEKDIR:
  489.  *    This symbol, if defined, indicates that the seekdir routine is
  490.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  491.  */
  492. #$d_seekdir HAS_SEEKDIR        /**/
  493.  
  494. /* HAS_TELLDIR:
  495.  *    This symbol, if defined, indicates that the telldir routine is
  496.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  497.  */
  498. #$d_telldir HAS_TELLDIR        /**/
  499.  
  500. /* HAS_REWINDDIR:
  501.  *    This symbol, if defined, indicates that the rewinddir routine is
  502.  *    available. You may have to include <dirent.h>. See I_DIRENT.
  503.  */
  504. #$d_rewinddir HAS_REWINDDIR        /**/
  505.  
  506. /* HAS_READLINK:
  507.  *    This symbol, if defined, indicates that the readlink routine is
  508.  *    available to read the value of a symbolic link.
  509.  */
  510. #$d_readlink HAS_READLINK        /**/
  511.  
  512. /* HAS_RENAME:
  513.  *    This symbol, if defined, indicates that the rename routine is available
  514.  *    to rename files.  Otherwise you should do the unlink(), link(), unlink()
  515.  *    trick.
  516.  */
  517. #$d_rename HAS_RENAME    /**/
  518.  
  519. /* HAS_RMDIR:
  520.  *    This symbol, if defined, indicates that the rmdir routine is
  521.  *    available to remove directories. Otherwise you should fork off a
  522.  *    new process to exec /bin/rmdir.
  523.  */
  524. #$d_rmdir HAS_RMDIR        /**/
  525.  
  526. /* HAS_SELECT:
  527.  *    This symbol, if defined, indicates that the select routine is
  528.  *    available to select active file descriptors. If the timeout field
  529.  *    is used, <sys/time.h> may need to be included.
  530.  */
  531. #$d_select HAS_SELECT    /**/
  532.  
  533. /* HAS_SEM:
  534.  *    This symbol, if defined, indicates that the entire sem*(2) library is
  535.  *    supported.
  536.  */
  537. #$d_sem HAS_SEM        /**/
  538.  
  539. /* HAS_SETEGID:
  540.  *    This symbol, if defined, indicates that the setegid routine is available
  541.  *    to change the effective gid of the current program.
  542.  */
  543. #$d_setegid HAS_SETEGID        /**/
  544.  
  545. /* HAS_SETEUID:
  546.  *    This symbol, if defined, indicates that the seteuid routine is available
  547.  *    to change the effective uid of the current program.
  548.  */
  549. #$d_seteuid HAS_SETEUID        /**/
  550.  
  551. /* HAS_SETLINEBUF:
  552.  *    This symbol, if defined, indicates that the setlinebuf routine is
  553.  *    available to change stderr or stdout from block-buffered or unbuffered
  554.  *    to a line-buffered mode.
  555.  */
  556. #$d_setlinebuf HAS_SETLINEBUF        /**/
  557.  
  558. /* HAS_SETLOCALE:
  559.  *    This symbol, if defined, indicates that the setlocale routine is
  560.  *    available to handle locale-specific ctype implementations.
  561.  */
  562. #$d_setlocale HAS_SETLOCALE    /**/
  563.  
  564. /* HAS_SETPGID:
  565.  *    This symbol, if defined, indicates that the setpgid(pid, gpid)
  566.  *    routine is available to set process group ID.
  567.  */
  568. #$d_setpgid HAS_SETPGID    /**/
  569.  
  570. /* HAS_SETPGRP:
  571.  *    This symbol, if defined, indicates that the setpgrp routine is
  572.  *    available to set the current process group.
  573.  */
  574. /* USE_BSD_SETPGRP:
  575.  *    This symbol, if defined, indicates that setpgrp needs two
  576.  *    arguments whereas USG one needs none.  See also HAS_SETPGID
  577.  *    for a POSIX interface.
  578.  */
  579. #$d_setpgrp HAS_SETPGRP        /**/
  580. #$d_bsdsetpgrp USE_BSD_SETPGRP    /**/
  581.  
  582. /* HAS_SETPGRP2:
  583.  *    This symbol, if defined, indicates that the setpgrp2() (as in DG/UX)
  584.  *    routine is available to set the current process group.
  585.  */
  586. #$d_setpgrp2 HAS_SETPGRP2        /**/
  587.  
  588. /* HAS_SETPRIORITY:
  589.  *    This symbol, if defined, indicates that the setpriority routine is
  590.  *    available to set a process's priority.
  591.  */
  592. #$d_setprior HAS_SETPRIORITY        /**/
  593.  
  594. /* HAS_SETREGID:
  595.  *    This symbol, if defined, indicates that the setregid routine is
  596.  *    available to change the real and effective gid of the current
  597.  *    process.
  598.  */
  599. /* HAS_SETRESGID:
  600.  *    This symbol, if defined, indicates that the setresgid routine is
  601.  *    available to change the real, effective and saved gid of the current
  602.  *    process.
  603.  */
  604. #$d_setregid HAS_SETREGID        /**/
  605. #$d_setresgid HAS_SETRESGID        /**/
  606.  
  607. /* HAS_SETREUID:
  608.  *    This symbol, if defined, indicates that the setreuid routine is
  609.  *    available to change the real and effective uid of the current
  610.  *    process.
  611.  */
  612. /* HAS_SETRESUID:
  613.  *    This symbol, if defined, indicates that the setresuid routine is
  614.  *    available to change the real, effective and saved uid of the current
  615.  *    process.
  616.  */
  617. #$d_setreuid HAS_SETREUID        /**/
  618. #$d_setresuid HAS_SETRESUID        /**/
  619.  
  620. /* HAS_SETRGID:
  621.  *    This symbol, if defined, indicates that the setrgid routine is available
  622.  *    to change the real gid of the current program.
  623.  */
  624. #$d_setrgid HAS_SETRGID        /**/
  625.  
  626. /* HAS_SETRUID:
  627.  *    This symbol, if defined, indicates that the setruid routine is available
  628.  *    to change the real uid of the current program.
  629.  */
  630. #$d_setruid HAS_SETRUID        /**/
  631.  
  632. /* HAS_SETSID:
  633.  *    This symbol, if defined, indicates that the setsid routine is
  634.  *    available to set the process group ID.
  635.  */
  636. #$d_setsid HAS_SETSID    /**/
  637.  
  638. /* HAS_SHM:
  639.  *    This symbol, if defined, indicates that the entire shm*(2) library is
  640.  *    supported.
  641.  */
  642. #$d_shm HAS_SHM        /**/
  643.  
  644. /* Shmat_t:
  645.  *    This symbol holds the return type of the shmat() system call.
  646.  *    Usually set to 'void *' or 'char *'.
  647.  */
  648. /* HAS_SHMAT_PROTOTYPE:
  649.  *    This symbol, if defined, indicates that the sys/shm.h includes
  650.  *    a prototype for shmat().  Otherwise, it is up to the program to
  651.  *    guess one.  Shmat_t shmat _((int, Shmat_t, int)) is a good guess,
  652.  *    but not always right so it should be emitted by the program only
  653.  *    when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs.
  654.  */
  655. #define Shmat_t $shmattype    /**/
  656. #$d_shmatprototype HAS_SHMAT_PROTOTYPE    /**/
  657.  
  658. /* USE_STAT_BLOCKS:
  659.  *    This symbol is defined if this system has a stat structure declaring
  660.  *    st_blksize and st_blocks.
  661.  */
  662. #$d_statblks USE_STAT_BLOCKS     /**/
  663.  
  664. /* HAS_STRCHR:
  665.  *    This symbol is defined to indicate that the strchr()/strrchr()
  666.  *    functions are available for string searching. If not, try the
  667.  *    index()/rindex() pair.
  668.  */
  669. /* HAS_INDEX:
  670.  *    This symbol is defined to indicate that the index()/rindex()
  671.  *    functions are available for string searching.
  672.  */
  673. #$d_strchr HAS_STRCHR    /**/
  674. #$d_index HAS_INDEX    /**/
  675.  
  676. /* HAS_STRCOLL:
  677.  *    This symbol, if defined, indicates that the strcoll routine is
  678.  *    available to compare strings using collating information.
  679.  */
  680. #$d_strcoll HAS_STRCOLL    /**/
  681.  
  682. /* USE_STRUCT_COPY:
  683.  *    This symbol, if defined, indicates that this C compiler knows how
  684.  *    to copy structures.  If undefined, you'll need to use a block copy
  685.  *    routine of some sort instead.
  686.  */
  687. #$d_strctcpy    USE_STRUCT_COPY    /**/
  688.  
  689. /* HAS_STRERROR:
  690.  *    This symbol, if defined, indicates that the strerror routine is
  691.  *    available to translate error numbers to strings. See the writeup
  692.  *    of Strerror() in this file before you try to define your own.
  693.  */
  694. /* HAS_SYS_ERRLIST:
  695.  *    This symbol, if defined, indicates that the sys_errlist array is
  696.  *    available to translate error numbers to strings. The extern int
  697.  *    sys_nerr gives the size of that table.
  698.  */
  699. /* Strerror:
  700.  *    This preprocessor symbol is defined as a macro if strerror() is
  701.  *    not available to translate error numbers to strings but sys_errlist[]
  702.  *    array is there.
  703.  */
  704. #$d_strerror HAS_STRERROR        /**/
  705. #$d_syserrlst HAS_SYS_ERRLIST    /**/
  706. #define Strerror(e) $d_strerrm
  707.  
  708. /* HAS_STRTOD:
  709.  *    This symbol, if defined, indicates that the strtod routine is
  710.  *    available to provide better numeric string conversion than atof().
  711.  */
  712. #$d_strtod HAS_STRTOD    /**/
  713.  
  714. /* HAS_STRTOL:
  715.  *    This symbol, if defined, indicates that the strtol routine is available
  716.  *    to provide better numeric string conversion than atoi() and friends.
  717.  */
  718. #$d_strtol HAS_STRTOL    /**/
  719.  
  720. /* HAS_STRTOUL:
  721.  *    This symbol, if defined, indicates that the strtoul routine is
  722.  *    available to provide conversion of strings to unsigned long.
  723.  */
  724. #$d_strtoul HAS_STRTOUL    /**/
  725.  
  726. /* HAS_STRXFRM:
  727.  *    This symbol, if defined, indicates that the strxfrm() routine is
  728.  *    available to transform strings.
  729.  */
  730. #$d_strxfrm HAS_STRXFRM    /**/
  731.  
  732. /* HAS_SYMLINK:
  733.  *    This symbol, if defined, indicates that the symlink routine is available
  734.  *    to create symbolic links.
  735.  */
  736. #$d_symlink HAS_SYMLINK    /**/
  737.  
  738. /* HAS_SYSCALL:
  739.  *    This symbol, if defined, indicates that the syscall routine is
  740.  *    available to call arbitrary system calls. If undefined, that's tough.
  741.  */
  742. #$d_syscall HAS_SYSCALL    /**/
  743.  
  744. /* HAS_SYSCONF:
  745.  *    This symbol, if defined, indicates that sysconf() is available
  746.  *    to determine system related limits and options.
  747.  */
  748. #$d_sysconf HAS_SYSCONF    /**/
  749.  
  750. /* HAS_SYSTEM:
  751.  *    This symbol, if defined, indicates that the system routine is
  752.  *    available to issue a shell command.
  753.  */
  754. #$d_system HAS_SYSTEM    /**/
  755.  
  756. /* HAS_TCGETPGRP:
  757.  *    This symbol, if defined, indicates that the tcgetpgrp routine is
  758.  *    available to get foreground process group ID.
  759.  */
  760. #$d_tcgetpgrp HAS_TCGETPGRP        /**/
  761.  
  762. /* HAS_TCSETPGRP:
  763.  *    This symbol, if defined, indicates that the tcsetpgrp routine is
  764.  *    available to set foreground process group ID.
  765.  */
  766. #$d_tcsetpgrp HAS_TCSETPGRP        /**/
  767.  
  768. /* HAS_TRUNCATE:
  769.  *    This symbol, if defined, indicates that the truncate routine is
  770.  *    available to truncate files.
  771.  */
  772. #$d_truncate HAS_TRUNCATE    /**/
  773.  
  774. /* HAS_TZNAME:
  775.  *    This symbol, if defined, indicates that the tzname[] array is
  776.  *    available to access timezone names.
  777.  */
  778. #$d_tzname HAS_TZNAME        /**/
  779.  
  780. /* HAS_UMASK:
  781.  *    This symbol, if defined, indicates that the umask routine is
  782.  *    available to set and get the value of the file creation mask.
  783.  */
  784. #$d_umask HAS_UMASK        /**/
  785.  
  786. /* HAS_VFORK:
  787.  *    This symbol, if defined, indicates that vfork() exists.
  788.  */
  789. #$d_vfork HAS_VFORK    /**/
  790.  
  791. /* HASVOLATILE:
  792.  *    This symbol, if defined, indicates that this C compiler knows about
  793.  *    the volatile declaration.
  794.  */
  795. #$d_volatile    HASVOLATILE    /**/
  796. #ifndef HASVOLATILE
  797. #define volatile
  798. #endif
  799.  
  800. /* HAS_WAIT4:
  801.  *    This symbol, if defined, indicates that wait4() exists.
  802.  */
  803. #$d_wait4 HAS_WAIT4    /**/
  804.  
  805. /* HAS_WAITPID:
  806.  *    This symbol, if defined, indicates that the waitpid routine is
  807.  *    available to wait for child process.
  808.  */
  809. #$d_waitpid HAS_WAITPID    /**/
  810.  
  811. /* HAS_WCSTOMBS:
  812.  *    This symbol, if defined, indicates that the wcstombs routine is
  813.  *    available to convert wide character strings to multibyte strings.
  814.  */
  815. #$d_wcstombs HAS_WCSTOMBS    /**/
  816.  
  817. /* HAS_WCTOMB:
  818.  *    This symbol, if defined, indicates that the wctomb routine is available
  819.  *    to covert a wide character to a multibyte.
  820.  */
  821. #$d_wctomb HAS_WCTOMB        /**/
  822.  
  823. /* EBCDIC:
  824.  *    This symbol, if defined, indicates that this system uses
  825.  *    EBCDIC encoding.
  826.  */
  827. #$ebcdic    EBCDIC         /**/
  828.  
  829. /* I_ARPA_INET:
  830.  *    This symbol, if defined, indicates that <arpa/inet.h> exists and should
  831.  *    be included.
  832.  */
  833. #$i_arpainet I_ARPA_INET    /**/
  834.  
  835. /* I_DBM:
  836.  *    This symbol, if defined, indicates that <dbm.h> exists and should
  837.  *    be included.
  838.  */
  839. /* I_RPCSVC_DBM:
  840.  *    This symbol, if defined, indicates that <rpcsvc/dbm.h> exists and
  841.  *    should be included.
  842.  */
  843. #$i_dbm I_DBM    /**/
  844. #$i_rpcsvcdbm I_RPCSVC_DBM    /**/
  845.  
  846. /* I_DIRENT:
  847.  *    This symbol, if defined, indicates to the C program that it should
  848.  *    include <dirent.h>. Using this symbol also triggers the definition
  849.  *    of the Direntry_t define which ends up being 'struct dirent' or
  850.  *    'struct direct' depending on the availability of <dirent.h>.
  851.  */
  852. /* DIRNAMLEN:
  853.  *    This symbol, if defined, indicates to the C program that the length
  854.  *    of directory entry names is provided by a d_namlen field.  Otherwise
  855.  *    you need to do strlen() on the d_name field.
  856.  */
  857. /* Direntry_t:
  858.  *    This symbol is set to 'struct direct' or 'struct dirent' depending on
  859.  *    whether dirent is available or not. You should use this pseudo type to
  860.  *    portably declare your directory entries.
  861.  */
  862. #$i_dirent I_DIRENT        /**/
  863. #$d_dirnamlen DIRNAMLEN    /**/
  864. #define Direntry_t $direntrytype
  865.  
  866. /* I_DLFCN:
  867.  *    This symbol, if defined, indicates that <dlfcn.h> exists and should
  868.  *    be included.
  869.  */
  870. #$i_dlfcn I_DLFCN        /**/
  871.  
  872. /* I_FCNTL:
  873.  *    This manifest constant tells the C program to include <fcntl.h>.
  874.  */
  875. #$i_fcntl I_FCNTL    /**/
  876.  
  877. /* I_FLOAT:
  878.  *    This symbol, if defined, indicates to the C program that it should
  879.  *    include <float.h> to get definition of symbols like DBL_MAX or
  880.  *    DBL_MIN, i.e. machine dependent floating point values.
  881.  */
  882. #$i_float I_FLOAT        /**/
  883.  
  884. /* I_GRP:
  885.  *    This symbol, if defined, indicates to the C program that it should
  886.  *    include <grp.h>.
  887.  */
  888. /* GRPASSWD:
  889.  *    This symbol, if defined, indicates to the C program that struct group
  890.  *    contains gr_passwd.
  891.  */
  892. /* HAS_SETGRENT:
  893.  *    This symbol, if defined, indicates that the getgrent routine is
  894.  *    available for initializing sequential access of the group database.
  895.  */
  896. /* HAS_GETGRENT:
  897.  *    This symbol, if defined, indicates that the getgrent routine is
  898.  *    available for sequential access of the group database.
  899.  */
  900. /* HAS_ENDGRENT:
  901.  *    This symbol, if defined, indicates that the getgrent routine is
  902.  *    available for finalizing sequential access of the group database.
  903.  */
  904. #$i_grp I_GRP        /**/
  905. #$d_grpasswd GRPASSWD    /**/
  906. #$d_setgrent HAS_SETGRENT    /**/
  907. #$d_getgrent HAS_GETGRENT    /**/
  908. #$d_endgrent HAS_ENDGRENT    /**/
  909.  
  910. /* I_LIMITS:
  911.  *    This symbol, if defined, indicates to the C program that it should
  912.  *    include <limits.h> to get definition of symbols like WORD_BIT or
  913.  *    LONG_MAX, i.e. machine dependant limitations.
  914.  */
  915. #$i_limits I_LIMITS        /**/
  916.  
  917. /* I_LOCALE:
  918.  *    This symbol, if defined, indicates to the C program that it should
  919.  *    include <locale.h>.
  920.  */
  921. #$i_locale    I_LOCALE        /**/
  922.  
  923. /* I_MATH:
  924.  *    This symbol, if defined, indicates to the C program that it should
  925.  *    include <math.h>.
  926.  */
  927. #$i_math I_MATH        /**/
  928.  
  929. /* I_MEMORY:
  930.  *    This symbol, if defined, indicates to the C program that it should
  931.  *    include <memory.h>.
  932.  */
  933. #$i_memory I_MEMORY        /**/
  934.  
  935. /* I_NDBM:
  936.  *    This symbol, if defined, indicates that <ndbm.h> exists and should
  937.  *    be included.
  938.  */
  939. #$i_ndbm I_NDBM    /**/
  940.  
  941. /* I_NET_ERRNO:
  942.  *    This symbol, if defined, indicates that <net/errno.h> exists and 
  943.  *    should be included.
  944.  */
  945. #$i_neterrno I_NET_ERRNO        /**/
  946.  
  947. /* I_NETINET_IN:
  948.  *    This symbol, if defined, indicates to the C program that it should
  949.  *    include <netinet/in.h>. Otherwise, you may try <sys/in.h>.
  950.  */
  951. #$i_niin I_NETINET_IN    /**/
  952.  
  953. /* I_SFIO:
  954.  *    This symbol, if defined, indicates to the C program that it should
  955.  *    include <sfio.h>.
  956.  */
  957. #$i_sfio    I_SFIO        /**/
  958.  
  959. /* I_STDDEF:
  960.  *    This symbol, if defined, indicates that <stddef.h> exists and should
  961.  *    be included.
  962.  */
  963. #$i_stddef I_STDDEF    /**/
  964.  
  965. /* I_STDLIB:
  966.  *    This symbol, if defined, indicates that <stdlib.h> exists and should
  967.  *    be included.
  968.  */
  969. #$i_stdlib I_STDLIB        /**/
  970.  
  971. /* I_STRING:
  972.  *    This symbol, if defined, indicates to the C program that it should
  973.  *    include <string.h> (USG systems) instead of <strings.h> (BSD systems).
  974.  */
  975. #$i_string I_STRING        /**/
  976.  
  977. /* I_SYS_DIR:
  978.  *    This symbol, if defined, indicates to the C program that it should
  979.  *    include <sys/dir.h>.
  980.  */
  981. #$i_sysdir I_SYS_DIR        /**/
  982.  
  983. /* I_SYS_FILE:
  984.  *    This symbol, if defined, indicates to the C program that it should
  985.  *    include <sys/file.h> to get definition of R_OK and friends.
  986.  */
  987. #$i_sysfile I_SYS_FILE        /**/
  988.  
  989. /* I_SYS_IOCTL:
  990.  *    This symbol, if defined, indicates that <sys/ioctl.h> exists and should
  991.  *    be included. Otherwise, include <sgtty.h> or <termio.h>.
  992.  */
  993. #$i_sysioctl    I_SYS_IOCTL        /**/
  994.  
  995. /* I_SYS_NDIR:
  996.  *    This symbol, if defined, indicates to the C program that it should
  997.  *    include <sys/ndir.h>.
  998.  */
  999. #$i_sysndir I_SYS_NDIR    /**/
  1000.  
  1001. /* I_SYS_PARAM:
  1002.  *    This symbol, if defined, indicates to the C program that it should
  1003.  *    include <sys/param.h>.
  1004.  */
  1005. #$i_sysparam I_SYS_PARAM        /**/
  1006.  
  1007. /* I_SYS_RESOURCE:
  1008.  *    This symbol, if defined, indicates to the C program that it should
  1009.  *    include <sys/resource.h>.
  1010.  */
  1011. #$i_sysresrc I_SYS_RESOURCE        /**/
  1012.  
  1013. /* I_SYS_SELECT:
  1014.  *    This symbol, if defined, indicates to the C program that it should
  1015.  *    include <sys/select.h> in order to get definition of struct timeval.
  1016.  */
  1017. #$i_sysselct I_SYS_SELECT    /**/
  1018.  
  1019. /* I_SYS_STAT:
  1020.  *    This symbol, if defined, indicates to the C program that it should
  1021.  *    include <sys/stat.h>.
  1022.  */
  1023. #$i_sysstat    I_SYS_STAT        /**/
  1024.  
  1025. /* I_SYS_TIMES:
  1026.  *    This symbol, if defined, indicates to the C program that it should
  1027.  *    include <sys/times.h>.
  1028.  */
  1029. #$i_systimes    I_SYS_TIMES        /**/
  1030.  
  1031. /* I_SYS_TYPES:
  1032.  *    This symbol, if defined, indicates to the C program that it should
  1033.  *    include <sys/types.h>.
  1034.  */
  1035. #$i_systypes    I_SYS_TYPES        /**/
  1036.  
  1037. /* I_SYS_UN:
  1038.  *    This symbol, if defined, indicates to the C program that it should
  1039.  *    include <sys/un.h> to get UNIX domain socket definitions.
  1040.  */
  1041. #$i_sysun I_SYS_UN        /**/
  1042.  
  1043. /* I_SYS_WAIT:
  1044.  *    This symbol, if defined, indicates to the C program that it should
  1045.  *    include <sys/wait.h>.
  1046.  */
  1047. #$i_syswait I_SYS_WAIT    /**/
  1048.  
  1049. /* I_TERMIO:
  1050.  *    This symbol, if defined, indicates that the program should include
  1051.  *    <termio.h> rather than <sgtty.h>.  There are also differences in
  1052.  *    the ioctl() calls that depend on the value of this symbol.
  1053.  */
  1054. /* I_TERMIOS:
  1055.  *    This symbol, if defined, indicates that the program should include
  1056.  *    the POSIX termios.h rather than sgtty.h or termio.h.
  1057.  *    There are also differences in the ioctl() calls that depend on the
  1058.  *    value of this symbol.
  1059.  */
  1060. /* I_SGTTY:
  1061.  *    This symbol, if defined, indicates that the program should include
  1062.  *    <sgtty.h> rather than <termio.h>.  There are also differences in
  1063.  *    the ioctl() calls that depend on the value of this symbol.
  1064.  */
  1065. #$i_termio I_TERMIO        /**/
  1066. #$i_termios I_TERMIOS        /**/
  1067. #$i_sgtty I_SGTTY        /**/
  1068.  
  1069. /* I_UNISTD:
  1070.  *    This symbol, if defined, indicates to the C program that it should
  1071.  *    include <unistd.h>.
  1072.  */
  1073. #$i_unistd I_UNISTD        /**/
  1074.  
  1075. /* I_UTIME:
  1076.  *    This symbol, if defined, indicates to the C program that it should
  1077.  *    include <utime.h>.
  1078.  */
  1079. #$i_utime I_UTIME        /**/
  1080.  
  1081. /* I_VALUES:
  1082.  *    This symbol, if defined, indicates to the C program that it should
  1083.  *    include <values.h> to get definition of symbols like MINFLOAT or
  1084.  *    MAXLONG, i.e. machine dependant limitations.  Probably, you
  1085.  *    should use <limits.h> instead, if it is available.
  1086.  */
  1087. #$i_values I_VALUES        /**/
  1088.  
  1089. /* I_STDARG:
  1090.  *    This symbol, if defined, indicates that <stdarg.h> exists and should
  1091.  *    be included.
  1092.  */
  1093. /* I_VARARGS:
  1094.  *    This symbol, if defined, indicates to the C program that it should
  1095.  *    include <varargs.h>.
  1096.  */
  1097. #$i_stdarg I_STDARG        /**/
  1098. #$i_varargs I_VARARGS    /**/
  1099.  
  1100. /* I_VFORK:
  1101.  *    This symbol, if defined, indicates to the C program that it should
  1102.  *    include vfork.h.
  1103.  */
  1104. #$i_vfork I_VFORK    /**/
  1105.  
  1106. /* CAN_PROTOTYPE:
  1107.  *    If defined, this macro indicates that the C compiler can handle
  1108.  *    function prototypes.
  1109.  */
  1110. /* _:
  1111.  *    This macro is used to declare function parameters for folks who want
  1112.  *    to make declarations with prototypes using a different style than
  1113.  *    the above macros.  Use double parentheses.  For example:
  1114.  *
  1115.  *        int main _((int argc, char *argv[]));
  1116.  */
  1117. #$prototype    CAN_PROTOTYPE    /**/
  1118. #ifdef CAN_PROTOTYPE
  1119. #define    _(args) args
  1120. #else
  1121. #define    _(args) ()
  1122. #endif
  1123.  
  1124. /* SH_PATH:
  1125.  *    This symbol contains the full pathname to the shell used on this
  1126.  *    on this system to execute Bourne shell scripts.  Usually, this will be
  1127.  *    /bin/sh, though it's possible that some systems will have /bin/ksh,
  1128.  *    /bin/pdksh, /bin/ash, /bin/bash, or even something such as
  1129.  *    D:/bin/sh.exe.
  1130.  */
  1131. #define SH_PATH "$sh"  /**/
  1132.  
  1133. /* STDCHAR:
  1134.  *    This symbol is defined to be the type of char used in stdio.h.
  1135.  *    It has the values "unsigned char" or "char".
  1136.  */
  1137. #define STDCHAR $stdchar    /**/
  1138.  
  1139. /* MEM_ALIGNBYTES:
  1140.  *     This symbol contains the number of bytes required to align a
  1141.  *     double. Usual values are 2, 4 and 8.
  1142.  *     On NeXT starting with 3.2, you can build "Fat" Multiple Architecture
  1143.  *     Binaries (MAB) for targets with varying alignment.  This only matters
  1144.  *     for perl, where the config.h can be generated and installed on one
  1145.  *     system, and used by a different architecture to build an extension.
  1146.  *     The default is eight, for safety.
  1147.  */
  1148. #define MEM_ALIGNBYTES $alignbytes    /**/
  1149.  
  1150. /* BYTEORDER:
  1151.  *    This symbol holds the hexadecimal constant defined in byteorder,
  1152.  *    i.e. 0x1234 or 0x4321, etc...
  1153.  *    On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture
  1154.  *    Binaries (MAB) on either big endian or little endian machines.
  1155.  *    The endian-ness is available at compile-time.  This only matters
  1156.  *    for perl, where the config.h can be generated and installed on 
  1157.  *    one system, and used by a different architecture to build an
  1158.  *    extension.  Older versions of NeXT that might not have
  1159.  *    defined either *_ENDIAN__ were all on Motorola 680x0 series,
  1160.  *    so the default case (for NeXT) is big endian to catch them. 
  1161.  *    This might matter for NeXT 3.0.
  1162.  */
  1163. #ifndef NeXT
  1164. #define BYTEORDER 0x$byteorder    /* large digits for MSB */
  1165. #else  /* NeXT */
  1166. #ifdef __LITTLE_ENDIAN__
  1167. #define BYTEORDER 0x1234
  1168. #else /* __BIG_ENDIAN__ */
  1169. #define BYTEORDER 0x4321
  1170. #endif /* ENDIAN CHECK */
  1171. #endif /* NeXT */
  1172.  
  1173. /* CASTI32:
  1174.  *    This symbol is defined if the C compiler can cast negative
  1175.  *    or large floating point numbers to 32-bit ints.
  1176.  */
  1177. #$d_casti32    CASTI32        /**/
  1178.  
  1179. /* CASTNEGFLOAT:
  1180.  *    This symbol is defined if the C compiler can cast negative
  1181.  *    numbers to unsigned longs, ints and shorts.
  1182.  */
  1183. /* CASTFLAGS:
  1184.  *    This symbol contains flags that say what difficulties the compiler
  1185.  *    has casting odd floating values to unsigned long:
  1186.  *        0 = ok
  1187.  *        1 = couldn't cast < 0
  1188.  *        2 = couldn't cast >= 0x80000000
  1189.  *        4 = couldn't cast in argument expression list
  1190.  */
  1191. #$d_castneg    CASTNEGFLOAT        /**/
  1192. #define CASTFLAGS $castflags        /**/
  1193.  
  1194. /* VOID_CLOSEDIR:
  1195.  *    This symbol, if defined, indicates that the closedir() routine
  1196.  *    does not return a value.
  1197.  */
  1198. #$d_void_closedir VOID_CLOSEDIR        /**/
  1199.  
  1200. /* Gconvert:
  1201.  *    This preprocessor macro is defined to convert a floating point
  1202.  *    number to a string without a trailing decimal point.  This
  1203.  *    emulates the behavior of sprintf("%g"), but is sometimes much more
  1204.  *    efficient.  If gconvert() is not available, but gcvt() drops the
  1205.  *    trailing decimal point, then gcvt() is used.  If all else fails,
  1206.  *    a macro using sprintf("%g") is used. Arguments for the Gconvert
  1207.  *    macro are: value, number of digits, whether trailing zeros should
  1208.  *    be retained, and the output buffer.
  1209.  *    Possible values are:
  1210.  *        d_Gconvert='gconvert((x),(n),(t),(b))'
  1211.  *        d_Gconvert='gcvt((x),(n),(b))'
  1212.  *        d_Gconvert='sprintf((b),"%.*g",(n),(x))'
  1213.  *    The last two assume trailing zeros should not be kept.
  1214.  */
  1215. #define Gconvert(x,n,t,b) $d_Gconvert
  1216.  
  1217. /* HAS_GNULIBC:
  1218.  *    This symbol, if defined, indicates to the C program that 
  1219.  *    the GNU C library is being used.
  1220.  */
  1221. #$d_gnulibc HAS_GNULIBC      /**/
  1222. /* HAS_ISASCII:
  1223.  *    This manifest constant lets the C program know that isascii 
  1224.  *    is available.
  1225.  */
  1226. #$d_isascii HAS_ISASCII        /**/
  1227.  
  1228. /* HAS_LCHOWN:
  1229.  *    This symbol, if defined, indicates that the lchown routine is
  1230.  *    available to operate on a symbolic link (instead of following the
  1231.  *    link).
  1232.  */
  1233. #$d_lchown HAS_LCHOWN        /**/
  1234.  
  1235. /* HAS_OPEN3:
  1236.  *    This manifest constant lets the C program know that the three
  1237.  *    argument form of open(2) is available.
  1238.  */
  1239. #$d_open3 HAS_OPEN3        /**/
  1240.  
  1241. /* HAS_SAFE_BCOPY:
  1242.  *    This symbol, if defined, indicates that the bcopy routine is available
  1243.  *    to copy potentially overlapping memory blocks. Otherwise you should
  1244.  *    probably use memmove() or memcpy(). If neither is defined, roll your
  1245.  *    own version.
  1246.  */
  1247. #$d_safebcpy HAS_SAFE_BCOPY    /**/
  1248.  
  1249. /* HAS_SAFE_MEMCPY:
  1250.  *    This symbol, if defined, indicates that the memcpy routine is available
  1251.  *    to copy potentially overlapping memory blocks. Otherwise you should
  1252.  *    probably use memmove() or memcpy(). If neither is defined, roll your
  1253.  *    own version.
  1254.  */
  1255. #$d_safemcpy HAS_SAFE_MEMCPY    /**/
  1256.  
  1257. /* HAS_SANE_MEMCMP:
  1258.  *    This symbol, if defined, indicates that the memcmp routine is available
  1259.  *    and can be used to compare relative magnitudes of chars with their high
  1260.  *    bits set.  If it is not defined, roll your own version.
  1261.  */
  1262. #$d_sanemcmp HAS_SANE_MEMCMP    /**/
  1263.  
  1264. /* HAS_SIGACTION:
  1265.  *    This symbol, if defined, indicates that Vr4's sigaction() routine
  1266.  *    is available.
  1267.  */
  1268. #$d_sigaction HAS_SIGACTION    /**/
  1269.  
  1270. /* Sigjmp_buf:
  1271.  *    This is the buffer type to be used with Sigsetjmp and Siglongjmp.
  1272.  */
  1273. /* Sigsetjmp:
  1274.  *    This macro is used in the same way as sigsetjmp(), but will invoke
  1275.  *    traditional setjmp() if sigsetjmp isn't available.
  1276.  *    See HAS_SIGSETJMP.
  1277.  */
  1278. /* Siglongjmp:
  1279.  *    This macro is used in the same way as siglongjmp(), but will invoke
  1280.  *    traditional longjmp() if siglongjmp isn't available.
  1281.  *    See HAS_SIGSETJMP.
  1282.  */
  1283. #$d_sigsetjmp HAS_SIGSETJMP    /**/
  1284. #ifdef HAS_SIGSETJMP
  1285. #define Sigjmp_buf sigjmp_buf
  1286. #define Sigsetjmp(buf,save_mask) sigsetjmp((buf),(save_mask))
  1287. #define Siglongjmp(buf,retval) siglongjmp((buf),(retval))
  1288. #else
  1289. #define Sigjmp_buf jmp_buf
  1290. #define Sigsetjmp(buf,save_mask) setjmp((buf))
  1291. #define Siglongjmp(buf,retval) longjmp((buf),(retval))
  1292. #endif
  1293.  
  1294. /* USE_STDIO_PTR:
  1295.  *    This symbol is defined if the _ptr and _cnt fields (or similar)
  1296.  *    of the stdio FILE structure can be used to access the stdio buffer
  1297.  *    for a file handle.  If this is defined, then the FILE_ptr(fp)
  1298.  *    and FILE_cnt(fp) macros will also be defined and should be used
  1299.  *    to access these fields.
  1300.  */
  1301. /* FILE_ptr:
  1302.  *    This macro is used to access the _ptr field (or equivalent) of the
  1303.  *    FILE structure pointed to by its argument. This macro will always be
  1304.  *    defined if USE_STDIO_PTR is defined.
  1305.  */
  1306. /* STDIO_PTR_LVALUE:
  1307.  *    This symbol is defined if the FILE_ptr macro can be used as an
  1308.  *    lvalue.
  1309.  */
  1310. /* FILE_cnt:
  1311.  *    This macro is used to access the _cnt field (or equivalent) of the
  1312.  *    FILE structure pointed to by its argument. This macro will always be
  1313.  *    defined if USE_STDIO_PTR is defined.
  1314.  */
  1315. /* STDIO_CNT_LVALUE:
  1316.  *    This symbol is defined if the FILE_cnt macro can be used as an
  1317.  *    lvalue.
  1318.  */
  1319. #$d_stdstdio USE_STDIO_PTR     /**/
  1320. #ifdef USE_STDIO_PTR
  1321. #define FILE_ptr(fp)    $stdio_ptr
  1322. #$d_stdio_ptr_lval STDIO_PTR_LVALUE         /**/
  1323. #define FILE_cnt(fp)    $stdio_cnt
  1324. #$d_stdio_cnt_lval STDIO_CNT_LVALUE         /**/
  1325. #endif
  1326.  
  1327. /* USE_STDIO_BASE:
  1328.  *    This symbol is defined if the _base field (or similar) of the
  1329.  *    stdio FILE structure can be used to access the stdio buffer for
  1330.  *    a file handle.  If this is defined, then the FILE_base(fp) macro
  1331.  *    will also be defined and should be used to access this field.
  1332.  *    Also, the FILE_bufsiz(fp) macro will be defined and should be used
  1333.  *    to determine the number of bytes in the buffer.  USE_STDIO_BASE
  1334.  *    will never be defined unless USE_STDIO_PTR is.
  1335.  */
  1336. /* FILE_base:
  1337.  *    This macro is used to access the _base field (or equivalent) of the
  1338.  *    FILE structure pointed to by its argument. This macro will always be
  1339.  *    defined if USE_STDIO_BASE is defined.
  1340.  */
  1341. /* FILE_bufsiz:
  1342.  *    This macro is used to determine the number of bytes in the I/O
  1343.  *    buffer pointed to by _base field (or equivalent) of the FILE
  1344.  *    structure pointed to its argument. This macro will always be defined
  1345.  *    if USE_STDIO_BASE is defined.
  1346.  */
  1347. #$d_stdiobase USE_STDIO_BASE     /**/
  1348. #ifdef USE_STDIO_BASE
  1349. #define FILE_base(fp)    $stdio_base
  1350. #define FILE_bufsiz(fp)    $stdio_bufsiz
  1351. #endif
  1352.  
  1353. /* HAS_VPRINTF:
  1354.  *    This symbol, if defined, indicates that the vprintf routine is available
  1355.  *    to printf with a pointer to an argument list.  If unavailable, you
  1356.  *    may need to write your own, probably in terms of _doprnt().
  1357.  */
  1358. /* USE_CHAR_VSPRINTF:
  1359.  *    This symbol is defined if this system has vsprintf() returning type
  1360.  *    (char*).  The trend seems to be to declare it as "int vsprintf()".  It
  1361.  *    is up to the package author to declare vsprintf correctly based on the
  1362.  *    symbol.
  1363.  */
  1364. #$d_vprintf HAS_VPRINTF    /**/
  1365. #$d_charvspr USE_CHAR_VSPRINTF     /**/
  1366.  
  1367. /* DOUBLESIZE:
  1368.  *    This symbol contains the size of a double, so that the C preprocessor
  1369.  *    can make decisions based on it.
  1370.  */
  1371. #define DOUBLESIZE $doublesize        /**/
  1372.  
  1373. /* I_TIME:
  1374.  *    This symbol, if defined, indicates to the C program that it should
  1375.  *    include <time.h>.
  1376.  */
  1377. /* I_SYS_TIME:
  1378.  *    This symbol, if defined, indicates to the C program that it should
  1379.  *    include <sys/time.h>.
  1380.  */
  1381. /* I_SYS_TIME_KERNEL:
  1382.  *    This symbol, if defined, indicates to the C program that it should
  1383.  *    include <sys/time.h> with KERNEL defined.
  1384.  */
  1385. #$i_time I_TIME        /**/
  1386. #$i_systime I_SYS_TIME        /**/
  1387. #$i_systimek I_SYS_TIME_KERNEL        /**/
  1388.  
  1389. /* INTSIZE:
  1390.  *    This symbol contains the value of sizeof(int) so that the C
  1391.  *    preprocessor can make decisions based on it.
  1392.  */
  1393. /* LONGSIZE:
  1394.  *    This symbol contains the value of sizeof(long) so that the C
  1395.  *    preprocessor can make decisions based on it.
  1396.  */
  1397. /* SHORTSIZE:
  1398.  *    This symbol contains the value of sizeof(short) so that the C
  1399.  *    preprocessor can make decisions based on it.
  1400.  */
  1401. #define INTSIZE $intsize        /**/
  1402. #define LONGSIZE $longsize        /**/
  1403. #define SHORTSIZE $shortsize        /**/
  1404.  
  1405. /* VAL_O_NONBLOCK:
  1406.  *    This symbol is to be used during open() or fcntl(F_SETFL) to turn on
  1407.  *    non-blocking I/O for the file descriptor. Note that there is no way
  1408.  *    back, i.e. you cannot turn it blocking again this way. If you wish to
  1409.  *    alternatively switch between blocking and non-blocking, use the
  1410.  *    ioctl(FIOSNBIO) call instead, but that is not supported by all devices.
  1411.  */
  1412. /* VAL_EAGAIN:
  1413.  *    This symbol holds the errno error code set by read() when no data was
  1414.  *    present on the non-blocking file descriptor.
  1415.  */
  1416. /* RD_NODATA:
  1417.  *    This symbol holds the return code from read() when no data is present
  1418.  *    on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is
  1419.  *    not defined, then you can't distinguish between no data and EOF by
  1420.  *    issuing a read(). You'll have to find another way to tell for sure!
  1421.  */
  1422. /* EOF_NONBLOCK:
  1423.  *    This symbol, if defined, indicates to the C program that a read() on
  1424.  *    a non-blocking file descriptor will return 0 on EOF, and not the value
  1425.  *    held in RD_NODATA (-1 usually, in that case!).
  1426.  */
  1427. #define VAL_O_NONBLOCK $o_nonblock
  1428. #define VAL_EAGAIN $eagain
  1429. #define RD_NODATA $rd_nodata
  1430. #$d_eofnblk EOF_NONBLOCK
  1431.  
  1432. /* PTRSIZE:
  1433.  *    This symbol contains the size of a pointer, so that the C preprocessor
  1434.  *    can make decisions based on it.  It will be sizeof(void *) if
  1435.  *    the compiler supports (void *); otherwise it will be
  1436.  *    sizeof(char *).
  1437.  */
  1438. #define PTRSIZE $ptrsize        /**/
  1439.  
  1440. /* RANDBITS:
  1441.  *    This symbol contains the number of bits of random number the rand()
  1442.  *    function produces.  Usual values are 15, 16, and 31.
  1443.  */
  1444. #define RANDBITS $randbits        /**/
  1445.  
  1446. /* SSize_t:
  1447.  *    This symbol holds the type used by functions that return
  1448.  *    a count of bytes or an error condition.  It must be a signed type.
  1449.  *    It is usually ssize_t, but may be long or int, etc.
  1450.  *    It may be necessary to include <sys/types.h> or <unistd.h>
  1451.  *    to get any typedef'ed information.
  1452.  *    We will pick a type such that sizeof(SSize_t) == sizeof(Size_t).
  1453.  */
  1454. #define SSize_t $ssizetype     /* signed count of bytes */
  1455.  
  1456. /* OSNAME:
  1457.  *    This symbol contains the name of the operating system, as determined
  1458.  *    by Configure.  You shouldn't rely on it too much; the specific
  1459.  *    feature tests from Configure are generally more reliable.
  1460.  */
  1461. #define OSNAME "$osname"        /**/
  1462.  
  1463. /* CAT2:
  1464.  *    This macro catenates 2 tokens together.
  1465.  */
  1466. /* STRINGIFY:
  1467.  *    This macro surrounds its token with double quotes.
  1468.  */
  1469. #if $cpp_stuff == 1
  1470. #define CAT2(a,b)a/**/b
  1471. #define STRINGIFY(a)"a"
  1472.         /* If you can get stringification with catify, tell me how! */
  1473. #endif
  1474. #if $cpp_stuff == 42
  1475. #define CAT2(a,b)a ## b
  1476. #define StGiFy(a)# a
  1477. #define STRINGIFY(a)StGiFy(a)
  1478. #endif
  1479. #if $cpp_stuff != 1 && $cpp_stuff != 42
  1480. #include "Bletch: How does this C preprocessor catenate tokens?"
  1481. #endif
  1482.  
  1483. /* CSH:
  1484.  *    This symbol, if defined, contains the full pathname of csh.
  1485.  */
  1486. #$d_csh HAS_CSH        /**/
  1487. #ifdef HAS_CSH
  1488. #define CSH "$full_csh"    /**/
  1489. #endif
  1490.  
  1491. /* HAS_ENDHOSTENT:
  1492.  *    This symbol, if defined, indicates that the endhostent() routine is
  1493.  *    available to close whatever was being used for host queries.
  1494.  */
  1495. #$d_endhent HAS_ENDHOSTENT        /**/
  1496.  
  1497. /* HAS_ENDNETENT:
  1498.  *    This symbol, if defined, indicates that the endnetent() routine is
  1499.  *    available to close whatever was being used for network queries.
  1500.  */
  1501. #$d_endnent HAS_ENDNETENT        /**/
  1502.  
  1503. /* HAS_ENDPROTOENT:
  1504.  *    This symbol, if defined, indicates that the endprotoent() routine is
  1505.  *    available to close whatever was being used for protocol queries.
  1506.  */
  1507. #$d_endpent HAS_ENDPROTOENT        /**/
  1508.  
  1509. /* HAS_ENDSERVENT:
  1510.  *    This symbol, if defined, indicates that the endservent() routine is
  1511.  *    available to close whatever was being used for service queries.
  1512.  */
  1513. #$d_endsent HAS_ENDSERVENT        /**/
  1514.  
  1515. /* HAS_GETHOSTBYADDR:
  1516.  *    This symbol, if defined, indicates that the gethostbyaddr() routine is
  1517.  *    available to look up hosts by their IP addresses.
  1518.  */
  1519. #$d_gethbyaddr HAS_GETHOSTBYADDR        /**/
  1520.  
  1521. /* HAS_GETHOSTBYNAME:
  1522.  *    This symbol, if defined, indicates that the gethostbyname() routine is
  1523.  *    available to look up host names in some data base or other.
  1524.  */
  1525. #$d_gethbyname HAS_GETHOSTBYNAME        /**/
  1526.  
  1527. /* HAS_GETHOSTENT:
  1528.  *    This symbol, if defined, indicates that the gethostent() routine is
  1529.  *    available to look up host names in some data base or another.
  1530.  */
  1531. #$d_gethent HAS_GETHOSTENT        /**/
  1532.  
  1533. /* HAS_GETNETBYADDR:
  1534.  *    This symbol, if defined, indicates that the getnetbyaddr() routine is
  1535.  *    available to look up networks by their IP addresses.
  1536.  */
  1537. #$d_getnbyaddr HAS_GETNETBYADDR        /**/
  1538.  
  1539. /* HAS_GETNETBYNAME:
  1540.  *    This symbol, if defined, indicates that the getnetbyname() routine is
  1541.  *    available to look up networks by their names.
  1542.  */
  1543. #$d_getnbyname HAS_GETNETBYNAME        /**/
  1544.  
  1545. /* HAS_GETNETENT:
  1546.  *    This symbol, if defined, indicates that the getnetent() routine is
  1547.  *    available to look up network names in some data base or another.
  1548.  */
  1549. #$d_getnent HAS_GETNETENT        /**/
  1550.  
  1551. /* HAS_GETPROTOENT:
  1552.  *    This symbol, if defined, indicates that the getprotoent() routine is
  1553.  *    available to look up protocols in some data base or another.
  1554.  */
  1555. #$d_getpent HAS_GETPROTOENT        /**/
  1556.  
  1557. /* HAS_GETPROTOBYNAME:
  1558.  *    This symbol, if defined, indicates that the getprotobyname()
  1559.  *    routine is available to look up protocols by their name.
  1560.  */
  1561. /* HAS_GETPROTOBYNUMBER:
  1562.  *    This symbol, if defined, indicates that the getprotobynumber()
  1563.  *    routine is available to look up protocols by their number.
  1564.  */
  1565. #$d_getpbyname HAS_GETPROTOBYNAME        /**/
  1566. #$d_getpbynumber HAS_GETPROTOBYNUMBER        /**/
  1567.  
  1568. /* HAS_GETSERVENT:
  1569.  *    This symbol, if defined, indicates that the getservent() routine is
  1570.  *    available to look up network services in some data base or another.
  1571.  */
  1572. #$d_getsent HAS_GETSERVENT        /**/
  1573.  
  1574. /* HAS_GETSERVBYNAME:
  1575.  *    This symbol, if defined, indicates that the getservbyname()
  1576.  *    routine is available to look up services by their name.
  1577.  */
  1578. /* HAS_GETSERVBYPORT:
  1579.  *    This symbol, if defined, indicates that the getservbyport()
  1580.  *    routine is available to look up services by their port.
  1581.  */
  1582. #$d_getsbyname HAS_GETSERVBYNAME        /**/
  1583. #$d_getsbyport HAS_GETSERVBYPORT        /**/
  1584.  
  1585. /* HAS_LONG_DOUBLE:
  1586.  *    This symbol will be defined if the C compiler supports long
  1587.  *    doubles.
  1588.  */
  1589. /* LONG_DOUBLESIZE:
  1590.  *    This symbol contains the size of a long double, so that the 
  1591.  *    C preprocessor can make decisions based on it.  It is only
  1592.  *    defined if the system supports long doubles.
  1593.  */
  1594. #$d_longdbl HAS_LONG_DOUBLE        /**/
  1595. #ifdef HAS_LONG_DOUBLE
  1596. #define LONG_DOUBLESIZE $longdblsize        /**/
  1597. #endif
  1598.  
  1599. /* HAS_LONG_LONG:
  1600.  *    This symbol will be defined if the C compiler supports
  1601.  *    long long.
  1602.  */
  1603. /* LONGLONGSIZE:
  1604.  *    This symbol contains the size of a long long, so that the 
  1605.  *    C preprocessor can make decisions based on it.  It is only
  1606.  *    defined if the system supports long long.
  1607.  */
  1608. #$d_longlong HAS_LONG_LONG        /**/
  1609. #ifdef HAS_LONG_LONG
  1610. #define LONGLONGSIZE $longlongsize        /**/
  1611. #endif
  1612.  
  1613. /* HAS_SETGROUPS:
  1614.  *    This symbol, if defined, indicates that the setgroups() routine is
  1615.  *    available to set the list of process groups.  If unavailable, multiple
  1616.  *    groups are probably not supported.
  1617.  */
  1618. #$d_setgrps HAS_SETGROUPS        /**/
  1619.  
  1620. /* HAS_SETHOSTENT:
  1621.  *    This symbol, if defined, indicates that the sethostent() routine is
  1622.  *    available.
  1623.  */
  1624. #$d_sethent HAS_SETHOSTENT        /**/
  1625.  
  1626. /* HAS_SETNETENT:
  1627.  *    This symbol, if defined, indicates that the setnetent() routine is
  1628.  *    available.
  1629.  */
  1630. #$d_setnent HAS_SETNETENT        /**/
  1631.  
  1632. /* HAS_SETPROTOENT:
  1633.  *    This symbol, if defined, indicates that the setprotoent() routine is
  1634.  *    available.
  1635.  */
  1636. #$d_setpent HAS_SETPROTOENT        /**/
  1637.  
  1638. /* HAS_SETSERVENT:
  1639.  *    This symbol, if defined, indicates that the setservent() routine is
  1640.  *    available.
  1641.  */
  1642. #$d_setsent HAS_SETSERVENT        /**/
  1643.  
  1644. /* HAS_SETVBUF:
  1645.  *    This symbol, if defined, indicates that the setvbuf routine is
  1646.  *    available to change buffering on an open stdio stream.
  1647.  *    to a line-buffered mode.
  1648.  */
  1649. #$d_setvbuf HAS_SETVBUF        /**/
  1650.  
  1651. /* HAS_SOCKET:
  1652.  *    This symbol, if defined, indicates that the BSD socket interface is
  1653.  *    supported.
  1654.  */
  1655. /* HAS_SOCKETPAIR:
  1656.  *    This symbol, if defined, indicates that the BSD socketpair() call is
  1657.  *    supported.
  1658.  */
  1659. #$d_socket HAS_SOCKET        /**/
  1660. #$d_sockpair HAS_SOCKETPAIR    /**/
  1661.  
  1662. /* HAS_UNION_SEMUN:
  1663.  *    This symbol, if defined, indicates that the union semun is
  1664.  *    defined by including <sys/sem.h>.  If not, the user code
  1665.  *    probably needs to define it as:
  1666.  *    union semun {
  1667.  *        int val;
  1668.  *        struct semid_ds *buf;
  1669.  *        unsigned short *array;
  1670.  *    }
  1671.  */
  1672. /* USE_SEMCTL_SEMUN:
  1673.  *    This symbol, if defined, indicates that union semun is
  1674.  *    used for semctl IPC_STAT.
  1675.  */
  1676. /* USE_SEMCTL_SEMID_DS:
  1677.  *    This symbol, if defined, indicates that struct semid_ds * is
  1678.  *    used for semctl IPC_STAT.
  1679.  */
  1680. #$d_union_semun HAS_UNION_SEMUN    /**/
  1681. #$d_semctl_semun USE_SEMCTL_SEMUN    /**/
  1682. #$d_semctl_semid_ds USE_SEMCTL_SEMID_DS    /**/
  1683.  
  1684. /* Signal_t:
  1685.  *    This symbol's value is either "void" or "int", corresponding to the
  1686.  *    appropriate return type of a signal handler.  Thus, you can declare
  1687.  *    a signal handler using "Signal_t (*handler)()", and define the
  1688.  *    handler using "Signal_t handler(sig)".
  1689.  */
  1690. #define Signal_t $signal_t    /* Signal handler's return type */
  1691.  
  1692. /* Groups_t:
  1693.  *    This symbol holds the type used for the second argument to
  1694.  *    getgroups() and setgropus().  Usually, this is the same as
  1695.  *    gidtype (gid_t) , but sometimes it isn't.
  1696.  *    It can be int, ushort, uid_t, etc... 
  1697.  *    It may be necessary to include <sys/types.h> to get any 
  1698.  *    typedef'ed information.  This is only required if you have
  1699.  *    getgroups() or setgropus()..
  1700.  */
  1701. #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
  1702. #define Groups_t $groupstype    /* Type for 2nd arg to [sg]etgroups() */
  1703. #endif
  1704.  
  1705. /* I_NETDB:
  1706.  *    This symbol, if defined, indicates that <netdb.h> exists and
  1707.  *    should be included.
  1708.  */
  1709. #$i_netdb I_NETDB        /**/
  1710.  
  1711. /* I_PWD:
  1712.  *    This symbol, if defined, indicates to the C program that it should
  1713.  *    include <pwd.h>.
  1714.  */
  1715. /* PWQUOTA:
  1716.  *    This symbol, if defined, indicates to the C program that struct passwd
  1717.  *    contains pw_quota.
  1718.  */
  1719. /* PWAGE:
  1720.  *    This symbol, if defined, indicates to the C program that struct passwd
  1721.  *    contains pw_age.
  1722.  */
  1723. /* PWCHANGE:
  1724.  *    This symbol, if defined, indicates to the C program that struct passwd
  1725.  *    contains pw_change.
  1726.  */
  1727. /* PWCLASS:
  1728.  *    This symbol, if defined, indicates to the C program that struct passwd
  1729.  *    contains pw_class.
  1730.  */
  1731. /* PWEXPIRE:
  1732.  *    This symbol, if defined, indicates to the C program that struct passwd
  1733.  *    contains pw_expire.
  1734.  */
  1735. /* PWCOMMENT:
  1736.  *    This symbol, if defined, indicates to the C program that struct passwd
  1737.  *    contains pw_comment.
  1738.  */
  1739. /* PWGECOS:
  1740.  *    This symbol, if defined, indicates to the C program that struct passwd
  1741.  *    contains pw_gecos.
  1742.  */
  1743. /* PWPASSWD:
  1744.  *    This symbol, if defined, indicates to the C program that struct passwd
  1745.  *    contains pw_passwd.
  1746.  */
  1747. /* HAS_SETPWENT:
  1748.  *    This symbol, if defined, indicates that the getpwrent routine is
  1749.  *    available for initializing sequential access of the passwd database.
  1750.  */
  1751. /* HAS_GETPWENT:
  1752.  *    This symbol, if defined, indicates that the getpwent routine is
  1753.  *    available for sequential access of the password database.
  1754.  */
  1755. /* HAS_ENDPWENT:
  1756.  *    This symbol, if defined, indicates that the getpwent routine is
  1757.  *    available for finalizing sequential access of the passwd database.
  1758.  */
  1759. #$i_pwd I_PWD        /**/
  1760. #$d_pwquota PWQUOTA    /**/
  1761. #$d_pwage PWAGE    /**/
  1762. #$d_pwchange PWCHANGE    /**/
  1763. #$d_pwclass PWCLASS    /**/
  1764. #$d_pwexpire PWEXPIRE    /**/
  1765. #$d_pwcomment PWCOMMENT    /**/
  1766. #$d_pwgecos PWGECOS    /**/
  1767. #$d_pwpasswd PWPASSWD    /**/
  1768. #$d_setpwent HAS_SETPWENT    /**/
  1769. #$d_getpwent HAS_GETPWENT    /**/
  1770. #$d_endpwent HAS_ENDPWENT    /**/
  1771.  
  1772. /* Free_t:
  1773.  *    This variable contains the return type of free().  It is usually
  1774.  * void, but occasionally int.
  1775.  */
  1776. /* Malloc_t:
  1777.  *    This symbol is the type of pointer returned by malloc and realloc.
  1778.  */
  1779. #define Malloc_t $malloctype            /**/
  1780. #define Free_t $freetype            /**/
  1781.  
  1782. /* MYMALLOC:
  1783.  *    This symbol, if defined, indicates that we're using our own malloc.
  1784.  */
  1785. #$d_mymalloc MYMALLOC            /**/
  1786.  
  1787. /* SIG_NAME:
  1788.  *    This symbol contains a list of signal names in order of
  1789.  *    signal number. This is intended
  1790.  *    to be used as a static array initialization, like this:
  1791.  *        char *sig_name[] = { SIG_NAME };
  1792.  *    The signals in the list are separated with commas, and each signal
  1793.  *    is surrounded by double quotes. There is no leading SIG in the signal
  1794.  *    name, i.e. SIGQUIT is known as "QUIT".
  1795.  *    Gaps in the signal numbers (up to NSIG) are filled in with NUMnn,
  1796.  *    etc., where nn is the actual signal number (e.g. NUM37).
  1797.  *    The signal number for sig_name[i] is stored in sig_num[i].
  1798.  *    The last element is 0 to terminate the list with a NULL.  This
  1799.  *    corresponds to the 0 at the end of the sig_num list.
  1800.  */
  1801. /* SIG_NUM:
  1802.  *    This symbol contains a list of signal numbers, in the same order as the
  1803.  *    SIG_NAME list. It is suitable for static array initialization, as in:
  1804.  *        int sig_num[] = { SIG_NUM };
  1805.  *    The signals in the list are separated with commas, and the indices
  1806.  *    within that list and the SIG_NAME list match, so it's easy to compute
  1807.  *    the signal name from a number or vice versa at the price of a small
  1808.  *    dynamic linear lookup. 
  1809.  *    Duplicates are allowed, but are moved to the end of the list.
  1810.  *    The signal number corresponding to sig_name[i] is sig_number[i].
  1811.  *    if (i < NSIG) then sig_number[i] == i.  
  1812.  *    The last element is 0, corresponding to the 0 at the end of
  1813.  *    the sig_name list.
  1814.  */
  1815. #define SIG_NAME $sig_name_init        /**/
  1816. #define SIG_NUM  $sig_num            /**/
  1817.  
  1818. /* VOIDFLAGS:
  1819.  *    This symbol indicates how much support of the void type is given by this
  1820.  *    compiler.  What various bits mean:
  1821.  *
  1822.  *        1 = supports declaration of void
  1823.  *        2 = supports arrays of pointers to functions returning void
  1824.  *        4 = supports comparisons between pointers to void functions and
  1825.  *            addresses of void functions
  1826.  *        8 = suports declaration of generic void pointers
  1827.  *
  1828.  *    The package designer should define VOIDUSED to indicate the requirements
  1829.  *    of the package.  This can be done either by #defining VOIDUSED before
  1830.  *    including config.h, or by defining defvoidused in Myinit.U.  If the
  1831.  *    latter approach is taken, only those flags will be tested.  If the
  1832.  *    level of void support necessary is not present, defines void to int.
  1833.  */
  1834. #ifndef VOIDUSED
  1835. #define VOIDUSED $defvoidused
  1836. #endif
  1837. #define VOIDFLAGS $voidflags
  1838. #if (VOIDFLAGS & VOIDUSED) != VOIDUSED
  1839. #define void int        /* is void to be avoided? */
  1840. #define M_VOID            /* Xenix strikes again */
  1841. #endif
  1842.  
  1843. /* ARCHLIB:
  1844.  *    This variable, if defined, holds the name of the directory in
  1845.  *    which the user wants to put architecture-dependent public
  1846.  *    library files for $package.  It is most often a local directory
  1847.  *    such as /usr/local/lib.  Programs using this variable must be
  1848.  *    prepared to deal with filename expansion.  If ARCHLIB is the
  1849.  *    same as PRIVLIB, it is not defined, since presumably the
  1850.  *    program already searches PRIVLIB.
  1851.  */
  1852. /* ARCHLIB_EXP:
  1853.  *    This symbol contains the ~name expanded version of ARCHLIB, to be used
  1854.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1855.  */
  1856. #$d_archlib ARCHLIB "$archlib"        /**/
  1857. #$d_archlib ARCHLIB_EXP "$archlibexp"        /**/
  1858.  
  1859. /* DLSYM_NEEDS_UNDERSCORE:
  1860.  *    This symbol, if defined, indicates that we need to prepend an
  1861.  *    underscore to the symbol name before calling dlsym().  This only
  1862.  *    makes sense if you *have* dlsym, which we will presume is the
  1863.  *    case if you're using dl_dlopen.xs.
  1864.  */
  1865. #$d_dlsymun     DLSYM_NEEDS_UNDERSCORE     /**/
  1866.  
  1867. /* USE_SFIO:
  1868.  *    This symbol, if defined, indicates that sfio should
  1869.  *    be used.
  1870.  */
  1871. #$d_sfio    USE_SFIO        /**/
  1872.  
  1873. /* USE_DYNAMIC_LOADING:
  1874.  *    This symbol, if defined, indicates that dynamic loading of
  1875.  *    some sort is available.
  1876.  */
  1877. #$usedl USE_DYNAMIC_LOADING        /**/
  1878.  
  1879. /* DB_Prefix_t:
  1880.  *    This symbol contains the type of the prefix structure element
  1881.  *    in the <db.h> header file.  In older versions of DB, it was
  1882.  *    int, while in newer ones it is u_int32_t.
  1883.  */
  1884. /* DB_Hash_t:
  1885.  *    This symbol contains the type of the prefix structure element
  1886.  *    in the <db.h> header file.  In older versions of DB, it was
  1887.  *    int, while in newer ones it is size_t.
  1888.  */
  1889. #define DB_Hash_t    $db_hashtype        /**/
  1890. #define DB_Prefix_t    $db_prefixtype      /**/
  1891.  
  1892. /* PRIVLIB:
  1893.  *    This symbol contains the name of the private library for this package.
  1894.  *    The library is private in the sense that it needn't be in anyone's
  1895.  *    execution path, but it should be accessible by the world.  The program
  1896.  *    should be prepared to do ~ expansion.
  1897.  */
  1898. /* PRIVLIB_EXP:
  1899.  *    This symbol contains the ~name expanded version of PRIVLIB, to be used
  1900.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1901.  */
  1902. #define PRIVLIB "$privlib"        /**/
  1903. #define PRIVLIB_EXP "$privlibexp"        /**/
  1904.  
  1905. /* SITEARCH:
  1906.  *    This symbol contains the name of the private library for this package.
  1907.  *    The library is private in the sense that it needn't be in anyone's
  1908.  *    execution path, but it should be accessible by the world.  The program
  1909.  *    should be prepared to do ~ expansion.
  1910.  *    The standard distribution will put nothing in this directory.
  1911.  *    Individual sites may place their own extensions and modules in
  1912.  *    this directory.
  1913.  */
  1914. /* SITEARCH_EXP:
  1915.  *    This symbol contains the ~name expanded version of SITEARCH, to be used
  1916.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1917.  */
  1918. #define SITEARCH "$sitearch"        /**/
  1919. #define SITEARCH_EXP "$sitearchexp"        /**/
  1920.  
  1921. /* SITELIB:
  1922.  *    This symbol contains the name of the private library for this package.
  1923.  *    The library is private in the sense that it needn't be in anyone's
  1924.  *    execution path, but it should be accessible by the world.  The program
  1925.  *    should be prepared to do ~ expansion.
  1926.  *    The standard distribution will put nothing in this directory.
  1927.  *    Individual sites may place their own extensions and modules in
  1928.  *    this directory.
  1929.  */
  1930. /* SITELIB_EXP:
  1931.  *    This symbol contains the ~name expanded version of SITELIB, to be used
  1932.  *    in programs that are not prepared to deal with ~ expansion at run-time.
  1933.  */
  1934. #define SITELIB "$sitelib"        /**/
  1935. #define SITELIB_EXP "$sitelibexp"        /**/
  1936.  
  1937. /* STARTPERL:
  1938.  *    This variable contains the string to put in front of a perl
  1939.  *    script to make sure (one hopes) that it runs with perl and not
  1940.  *    some shell.
  1941.  */
  1942. #define STARTPERL "$startperl"        /**/
  1943.  
  1944. /* USE_PERLIO:
  1945.  *    This symbol, if defined, indicates that the PerlIO abstraction should
  1946.  *    be used throughout.  If not defined, stdio should be
  1947.  *    used in a fully backward compatible manner.
  1948.  */
  1949. #$useperlio    USE_PERLIO        /**/
  1950.  
  1951. /* HAS_GETHOST_PROTOS:
  1952.  *    This symbol, if defined, indicates that <netdb.h> includes
  1953.  *    prototypes for gethostent(), gethostbyname(), and
  1954.  *    gethostbyaddr().  Otherwise, it is up to the program to guess
  1955.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  1956.  */
  1957. #$d_gethostprotos    HAS_GETHOST_PROTOS    /**/
  1958.  
  1959. /* HAS_GETNET_PROTOS:
  1960.  *    This symbol, if defined, indicates that <netdb.h> includes
  1961.  *    prototypes for getnetent(), getnetbyname(), and
  1962.  *    getnetbyaddr().  Otherwise, it is up to the program to guess
  1963.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  1964.  */
  1965. #$d_getnetprotos    HAS_GETNET_PROTOS    /**/
  1966.  
  1967. /* HAS_GETPROTO_PROTOS:
  1968.  *    This symbol, if defined, indicates that <netdb.h> includes
  1969.  *    prototypes for getprotoent(), getprotobyname(), and
  1970.  *    getprotobyaddr().  Otherwise, it is up to the program to guess
  1971.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  1972.  */
  1973. #$d_getprotoprotos    HAS_GETPROTO_PROTOS    /**/
  1974.  
  1975. /* HAS_GETSERV_PROTOS:
  1976.  *    This symbol, if defined, indicates that <netdb.h> includes
  1977.  *    prototypes for getservent(), getservbyname(), and
  1978.  *    getservbyaddr().  Otherwise, it is up to the program to guess
  1979.  *    them.  See netdbtype.U for probing for various Netdb_xxx_t types.
  1980.  */
  1981. #$d_getservprotos    HAS_GETSERV_PROTOS    /**/
  1982.  
  1983. /* Netdb_host_t:
  1984.  *    This symbol holds the type used for the 1st argument
  1985.  *    to gethostbyaddr().
  1986.  */
  1987. /* Netdb_hlen_t:
  1988.  *    This symbol holds the type used for the 2nd argument
  1989.  *    to gethostbyaddr().
  1990.  */
  1991. /* Netdb_name_t:
  1992.  *    This symbol holds the type used for the argument to
  1993.  *    gethostbyname().
  1994.  */
  1995. /* Netdb_net_t:
  1996.  *    This symbol holds the type used for the 1st argument to
  1997.  *    getnetbyaddr().
  1998.  */
  1999. #define Netdb_host_t        $netdb_host_type /**/
  2000. #define Netdb_hlen_t        $netdb_hlen_type /**/
  2001. #define Netdb_name_t        $netdb_name_type /**/
  2002. #define Netdb_net_t        $netdb_net_type /**/
  2003.  
  2004. /* Select_fd_set_t:
  2005.  *    This symbol holds the type used for the 2nd, 3rd, and 4th
  2006.  *    arguments to select.  Usually, this is 'fd_set *', if HAS_FD_SET
  2007.  *    is defined, and 'int *' otherwise.  This is only useful if you 
  2008.  *    have select(), of course.
  2009.  */
  2010. #define Select_fd_set_t     $selecttype    /**/
  2011.  
  2012. /* ARCHNAME:
  2013.  *    This symbol holds a string representing the architecture name.
  2014.  *    It may be used to construct an architecture-dependant pathname
  2015.  *    where library files may be held under a private library, for
  2016.  *    instance.
  2017.  */
  2018. #define ARCHNAME "$archname"        /**/
  2019.  
  2020. /* HAS_PTHREAD_YIELD:
  2021.  *    This symbol, if defined, indicates that the pthread_yield 
  2022.  *    routine is available to yield the execution of the current
  2023.  *    thread.
  2024.  */
  2025. /* HAS_SCHED_YIELD:
  2026.  *    This symbol, if defined, indicates that the sched_yield
  2027.  *    routine is available to yield the execution of the current
  2028.  *    thread.
  2029.  */
  2030. #$d_pthread_yield HAS_PTHREAD_YIELD    /**/
  2031. #$d_sched_yield HAS_SCHED_YIELD    /**/
  2032.  
  2033. /* PTHREADS_CREATED_JOINABLE:
  2034.  *    This symbol, if defined, indicates that pthreads are created
  2035.  *    in the joinable (aka undetached) state.
  2036.  */
  2037. #$d_pthreads_created_joinable PTHREADS_CREATED_JOINABLE /**/
  2038.  
  2039. /* USE_THREADS:
  2040.  *    This symbol, if defined, indicates that Perl should
  2041.  *    be built to use threads.
  2042.  */
  2043. /* OLD_PTHREADS_API:
  2044.  *    This symbol, if defined, indicates that Perl should
  2045.  *    be built to use the old draft POSIX threads API.
  2046.  */
  2047. #$usethreads    USE_THREADS        /**/
  2048. #$d_oldpthreads    OLD_PTHREADS_API        /**/
  2049.  
  2050. /* Time_t:
  2051.  *    This symbol holds the type returned by time(). It can be long,
  2052.  *    or time_t on BSD sites (in which case <sys/types.h> should be
  2053.  *    included).
  2054.  */
  2055. #define Time_t $timetype        /* Time type */
  2056.  
  2057. /* HAS_TIMES:
  2058.  *    This symbol, if defined, indicates that the times() routine exists.
  2059.  *    Note that this became obsolete on some systems (SUNOS), which now
  2060.  * use getrusage(). It may be necessary to include <sys/times.h>.
  2061.  */
  2062. #$d_times HAS_TIMES        /**/
  2063.  
  2064. /* Fpos_t:
  2065.  *    This symbol holds the type used to declare file positions in libc.
  2066.  *    It can be fpos_t, long, uint, etc... It may be necessary to include
  2067.  *    <sys/types.h> to get any typedef'ed information.
  2068.  */
  2069. #define Fpos_t $fpostype        /* File position type */
  2070.  
  2071. /* Gid_t:
  2072.  *    This symbol holds the return type of getgid() and the type of
  2073.  *    argument to setrgid() and related functions.  Typically,
  2074.  *    it is the type of group ids in the kernel. It can be int, ushort,
  2075.  *    uid_t, etc... It may be necessary to include <sys/types.h> to get
  2076.  *    any typedef'ed information.
  2077.  */
  2078. #define Gid_t $gidtype        /* Type for getgid(), etc... */
  2079.  
  2080. /* Off_t:
  2081.  *    This symbol holds the type used to declare offsets in the kernel.
  2082.  *    It can be int, long, off_t, etc... It may be necessary to include
  2083.  *    <sys/types.h> to get any typedef'ed information.
  2084.  */
  2085. #define Off_t $lseektype        /* <offset> type */
  2086.  
  2087. /* Mode_t:
  2088.  *    This symbol holds the type used to declare file modes 
  2089.  *    for systems calls.  It is usually mode_t, but may be
  2090.  *    int or unsigned short.  It may be necessary to include <sys/types.h>
  2091.  *    to get any typedef'ed information.
  2092.  */
  2093. #define Mode_t $modetype     /* file mode parameter for system calls */
  2094.  
  2095. /* Pid_t:
  2096.  *    This symbol holds the type used to declare process ids in the kernel.
  2097.  *    It can be int, uint, pid_t, etc... It may be necessary to include
  2098.  *    <sys/types.h> to get any typedef'ed information.
  2099.  */
  2100. #define Pid_t $pidtype        /* PID type */
  2101.  
  2102. /* Size_t:
  2103.  *    This symbol holds the type used to declare length parameters
  2104.  *    for string functions.  It is usually size_t, but may be
  2105.  *    unsigned long, int, etc.  It may be necessary to include
  2106.  *    <sys/types.h> to get any typedef'ed information.
  2107.  */
  2108. #define Size_t $sizetype     /* length paramater for string functions */
  2109.  
  2110. /* Uid_t:
  2111.  *    This symbol holds the type used to declare user ids in the kernel.
  2112.  *    It can be int, ushort, uid_t, etc... It may be necessary to include
  2113.  *    <sys/types.h> to get any typedef'ed information.
  2114.  */
  2115. #define Uid_t $uidtype        /* UID type */
  2116.  
  2117. #endif
  2118. !GROK!THIS!
  2119.